/**
 * @file protocol_interface.c
 * @brief 104协议库用户接口实现
 * @details 实现用户友好的协议接口函数
 * 
 * @author zyb
 * @date 2025-10-19
 * @version 1.0
 */

#include "protocol_interface.h"
#include "../../common/utils/include/protocol104_integrated.h"
#include "../../../../../common/logs/include/logger.h"
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
#include <stdbool.h>

// 定义模块名称
#define LOG_MODULE_NAME "PROTOCOL_INTERFACE"

/* 协议配置结构 */
struct protocol_config {
    const char* server_ip;             // 服务器IP
    uint16_t server_port;              // 服务器端口
    // 公共地址使用协议标准规定的宏定义 PROTOCOL_104_COMMON_ADDRESS
    uint32_t timeout_ms;               // 超时时间（毫秒）
    bool auto_reconnect;               // 自动重连
};

/* 数据点结构已在头文件中定义 */

/* 回调函数类型 */
typedef void (*protocol_data_callback_t)(const data_point_t* data, void* user_data);
typedef void (*protocol_send_result_callback_t)(send_result_t result, const char* message, void* user_data);

/* 协议句柄内部结构 */
struct protocol_handle {
    struct protocol_config config;
    protocol_data_callback_t data_callback;
    protocol_send_result_callback_t send_result_callback;
    void* user_data;
    int connected;
    pthread_mutex_t mutex;
};

/* ==================== 内部函数声明 ==================== */

static void protocol_private_cleanup(struct protocol_handle* private_data);
static int protocol_private_validate_config(const struct protocol_config* config);

/* ==================== 用户接口函数实现 ==================== */

/**
 * @brief 创建协议实例
 * @details 根据提供的配置参数创建新的104协议实例。该函数会验证配置参数的有效性，
 *          分配必要的内存资源，初始化互斥锁，并设置协议的基本配置。
 *          创建成功后返回协议句柄，可用于后续的协议操作。
 * 
 * @param config 协议配置参数，包含服务器IP、端口、公共地址等信息，不能为NULL
 * @return 协议句柄
 *         - 成功: 返回有效的协议句柄指针
 *         - 失败: 返回NULL
 * 
 * @note 调用者负责在不再使用时调用protocol_destroy()释放资源
 * @warning 配置参数必须有效，否则创建会失败
 * 
 * @see protocol_destroy
 * @see protocol_connect
 * @see protocol_config_t
 */
protocol_handle_t protocol_create(const protocol_config_t* config) {
    LOG_DEBUG(LOG_MODULE_NAME, "创建协议实例: config=%p", config);
    
    // 检查输入参数是否为空
    if (config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "空指针参数错误");
        return NULL;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "开始创建协议实例");
    
    // 验证配置
    LOG_DEBUG(LOG_MODULE_NAME, "验证协议配置");
    if (protocol_private_validate_config(config) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "协议配置验证失败");
        return NULL;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "协议配置验证成功");
    
    // 分配私有数据结构
    LOG_DEBUG(LOG_MODULE_NAME, "分配私有数据结构，大小: %zu", sizeof(struct protocol_handle));
    struct protocol_handle* private_data = 
        (struct protocol_handle*)malloc(sizeof(struct protocol_handle));
    if (private_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "内存分配失败");
        return NULL;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "私有数据结构分配成功: %p", private_data);
    
    // 初始化私有数据结构
    memset(private_data, 0, sizeof(struct protocol_handle));
    LOG_DEBUG(LOG_MODULE_NAME, "私有数据结构清零完成");
    
    // 复制配置
    LOG_DEBUG(LOG_MODULE_NAME, "复制协议配置，大小: %zu", sizeof(protocol_config_t));
    memcpy(&private_data->config, config, sizeof(protocol_config_t));
    LOG_DEBUG(LOG_MODULE_NAME, "协议配置复制完成");
    
    // 初始化互斥锁
    LOG_DEBUG(LOG_MODULE_NAME, "初始化互斥锁");
    if (pthread_mutex_init(&private_data->mutex, NULL) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "互斥锁初始化失败");
        free(private_data);
        return NULL;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "互斥锁初始化成功");
    
    LOG_INFO(LOG_MODULE_NAME, "协议实例创建成功: %p", private_data);
    return (protocol_handle_t)private_data;
}

/**
 * @brief 销毁协议实例
 * @details 销毁指定的协议实例，释放所有相关的资源。该函数会先断开协议连接，
 *          然后清理私有数据结构，包括销毁互斥锁和释放内存。
 *          调用此函数后，协议句柄将不再有效，不应继续使用。
 * 
 * @param handle 协议句柄，由protocol_create()创建，可以为NULL
 * 
 * @note 该函数是线程安全的，可以安全地从多个线程调用
 * @warning 调用此函数后，协议句柄将不再有效
 * 
 * @see protocol_create
 * @see protocol_disconnect
 */
void protocol_destroy(protocol_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "销毁协议实例: handle=%p", handle);
    
    // 检查输入参数是否为空
    if (handle == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "协议句柄为空，跳过销毁");
        return;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 断开连接
    LOG_DEBUG(LOG_MODULE_NAME, "断开协议连接");
    protocol_disconnect(handle);
    
    // 清理资源
    LOG_DEBUG(LOG_MODULE_NAME, "清理协议资源");
    protocol_private_cleanup(private_data);
    
    LOG_INFO(LOG_MODULE_NAME, "协议实例销毁完成");
}

/**
 * @brief 连接服务器
 * @details 建立与104协议服务器的连接。该函数会检查当前连接状态，
 *          如果已经连接则直接返回成功，否则尝试建立新的连接。
 *          连接建立后，可以进行数据发送和接收操作。
 * 
 * @param handle 协议句柄，由protocol_create()创建，不能为NULL
 * @return 连接结果
 *         - 0: 连接成功或已经连接
 *         - -1: 连接失败（参数无效）
 * 
 * @note 该函数是线程安全的，使用互斥锁保护连接状态
 * @warning 连接失败时请检查网络配置和服务器状态
 * 
 * @see protocol_disconnect
 * @see protocol_is_connected
 * @see protocol_send_data
 */
int protocol_connect(protocol_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "连接服务器: handle=%p", handle);
    
    // 检查输入参数是否为空
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "协议句柄为空");
        return -1;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 加锁保护连接状态
    pthread_mutex_lock(&private_data->mutex);
    
    // 检查是否已经连接
    if (private_data->connected) {
        LOG_DEBUG(LOG_MODULE_NAME, "协议已经连接");
        pthread_mutex_unlock(&private_data->mutex);
        return 0; // 已经连接
    }
    
    // 模拟连接过程
    LOG_DEBUG(LOG_MODULE_NAME, "开始连接服务器: %s:%u", 
              private_data->config.server_ip, private_data->config.server_port);
    private_data->connected = 1;
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "协议连接成功");
    return 0;
}

/**
 * @brief 断开连接
 * @details 断开与104协议服务器的连接。该函数会检查当前连接状态，
 *          如果已经断开则直接返回，否则执行断开操作。
 *          断开连接后，无法进行数据发送和接收操作。
 * 
 * @param handle 协议句柄，由protocol_create()创建，可以为NULL
 * 
 * @note 该函数是线程安全的，使用互斥锁保护连接状态
 * @note 断开连接后，需要重新调用protocol_connect()才能恢复连接
 * 
 * @see protocol_connect
 * @see protocol_is_connected
 * @see protocol_destroy
 */
void protocol_disconnect(protocol_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "断开连接: handle=%p", handle);
    
    // 检查输入参数是否为空
    if (handle == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "协议句柄为空，跳过断开");
        return;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 加锁保护连接状态
    pthread_mutex_lock(&private_data->mutex);
    
    // 检查是否已经断开
    if (!private_data->connected) {
        LOG_DEBUG(LOG_MODULE_NAME, "协议已经断开");
        pthread_mutex_unlock(&private_data->mutex);
        return;
    }
    
    // 断开连接
    LOG_DEBUG(LOG_MODULE_NAME, "断开协议连接");
    private_data->connected = 0;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "协议断开连接完成");
}

/**
 * @brief 发送数据
 * @details 通过104协议发送数据到服务器。该函数会检查连接状态和参数有效性，
 *          只有在连接状态下才能发送数据。发送的数据可以是单点信息、双点信息、
 *          测量值、控制命令等不同类型的协议数据。
 * 
 * @param handle 协议句柄，由protocol_create()创建，不能为NULL
 * @param data 要发送的协议数据，包含地址、类型、质量、时间戳和值等信息，不能为NULL
 * @return 发送结果
 *         - SEND_RESULT_SUCCESS: 发送成功
 *         - SEND_RESULT_INVALID_DATA: 数据无效（参数为空）
 *         - SEND_RESULT_DISCONNECTED: 连接断开
 * 
 * @note 该函数是线程安全的，使用互斥锁保护连接状态
 * @warning 发送前请确保协议已连接，否则会返回连接断开错误
 * 
 * @see protocol_connect
 * @see protocol_is_connected
 * @see protocol_data_t
 * @see send_result_t
 */
send_result_t protocol_send_data(protocol_handle_t handle, const struct data_point* data) {
    LOG_DEBUG(LOG_MODULE_NAME, "发送数据: handle=%p, data=%p", handle, data);
    
    // 检查输入参数是否为空
    if (handle == NULL || data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "参数为空，无法发送数据");
        return SEND_RESULT_INVALID_DATA;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 加锁保护连接状态
    pthread_mutex_lock(&private_data->mutex);
    
    // 检查连接状态
    if (!private_data->connected) {
        LOG_ERROR(LOG_MODULE_NAME, "协议未连接，无法发送数据");
        pthread_mutex_unlock(&private_data->mutex);
        return SEND_RESULT_DISCONNECTED;
    }
    
    // 模拟数据发送
    LOG_DEBUG(LOG_MODULE_NAME, "发送数据: 地址=%u, 类型=%d, 质量=%d", 
              data->address, data->type, data->quality);
    // 这里可以调用实际的协议发送函数
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "数据发送成功");
    return SEND_RESULT_SUCCESS;
}

/**
 * @brief 注册数据接收回调
 * @details 设置数据接收回调函数，当协议接收到数据时会调用此回调函数。
 *          回调函数会在协议线程中调用，因此回调函数应该尽快返回，
 *          避免阻塞协议处理。可以设置NULL来取消回调。
 * 
 * @param handle 协议句柄，由protocol_create()创建，不能为NULL
 * @param callback 数据接收回调函数，可以为NULL
 * @param user_data 用户数据指针，会传递给回调函数，可以为NULL
 * 
 * @note 该函数是线程安全的，使用互斥锁保护回调函数设置
 * @note 回调函数在协议线程中调用，应避免长时间阻塞
 * 
 * @see protocol_data_callback_t
 * @see protocol_data_t
 */
void protocol_set_data_callback(protocol_handle_t handle, 
                               protocol_data_callback_t callback, 
                               void* user_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置数据回调: handle=%p, callback=%p, user_data=%p", 
              handle, callback, user_data);
    
    // 检查输入参数是否为空
    if (handle == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "协议句柄为空，跳过设置回调");
        return;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 加锁保护回调函数设置
    pthread_mutex_lock(&private_data->mutex);
    private_data->data_callback = callback;
    private_data->user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "数据回调设置完成");
}

/**
 * @brief 注册发送结果回调
 * @details 设置数据发送结果回调函数，当数据发送完成时会调用此回调函数。
 *          回调函数会报告发送结果，包括成功、失败、超时、连接断开等情况。
 *          回调函数会在协议线程中调用，因此应该尽快返回，避免阻塞协议处理。
 * 
 * @param handle 协议句柄，由protocol_create()创建，不能为NULL
 * @param callback 发送结果回调函数，可以为NULL
 * @param user_data 用户数据指针，会传递给回调函数，可以为NULL
 * 
 * @note 该函数是线程安全的，使用互斥锁保护回调函数设置
 * @note 回调函数在协议线程中调用，应避免长时间阻塞
 * 
 * @see protocol_send_result_callback_t
 * @see send_result_t
 * @see protocol_send_data
 */
void protocol_set_send_result_callback(protocol_handle_t handle, 
                                      protocol_send_result_callback_t callback, 
                                      void* user_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置发送结果回调: handle=%p, callback=%p, user_data=%p", 
              handle, callback, user_data);
    
    // 检查输入参数是否为空
    if (handle == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "协议句柄为空，跳过设置回调");
        return;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 加锁保护回调函数设置
    pthread_mutex_lock(&private_data->mutex);
    private_data->send_result_callback = callback;
    private_data->user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "发送结果回调设置完成");
}

/**
 * @brief 检查连接状态
 * @details 检查协议实例的当前连接状态。该函数会安全地读取连接状态，
 *          不会影响当前的连接。返回true表示已连接，false表示未连接。
 * 
 * @param handle 协议句柄，由protocol_create()创建，不能为NULL
 * @return 连接状态
 *         - true: 已连接到服务器
 *         - false: 未连接或句柄无效
 * 
 * @note 该函数是线程安全的，使用互斥锁保护状态读取
 * @note 连接状态可能会在调用后立即改变，建议在关键操作前重新检查
 * 
 * @see protocol_connect
 * @see protocol_disconnect
 * @see protocol_send_data
 */
bool protocol_is_connected(protocol_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "检查连接状态: handle=%p", handle);
    
    // 检查输入参数是否为空
    if (handle == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "协议句柄为空，返回未连接状态");
        return false;
    }
    
    struct protocol_handle* private_data = (struct protocol_handle*)handle;
    
    // 加锁保护连接状态读取
    pthread_mutex_lock(&private_data->mutex);
    bool connected = private_data->connected;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "连接状态检查结果: %s", connected ? "已连接" : "未连接");
    return connected;
}

/**
 * @brief 获取版本信息
 * @details 获取104协议库的版本信息。返回的版本字符串是静态的，
 *          不需要释放内存。版本信息包含主版本号、次版本号和修订号。
 * 
 * @return 版本信息字符串，格式为"主版本.次版本.修订号"
 * 
 * @note 返回的字符串是静态常量，不需要释放内存
 * @note 版本信息在编译时确定，运行时不会改变
 * 
 * @see protocol_create
 * @see protocol_destroy
 */
/**
 * @brief 接收原始数据
 * @details 接收来自网络的原始数据并解析
 * 
 * @param handle 协议句柄，不能为NULL
 * @param raw_data 原始数据缓冲区
 * @param data_length 数据长度
 * @return 解析结果，0表示成功
 */
int protocol_receive_raw_data(protocol_handle_t handle, 
                             const uint8_t* raw_data, 
                             uint32_t data_length) {
    if (!handle || !raw_data || data_length == 0) {
        return -1;
    }
    
    // 这里应该调用core内部的解析函数
    // 暂时返回成功，实际实现需要调用apdu_parse等函数
    LOG_INFO(LOG_MODULE_NAME, "接收原始数据: %u 字节", data_length);
    return 0;
}

/**
 * @brief 获取解析后的数据
 * @details 获取最近解析的数据点
 * 
 * @param handle 协议句柄，不能为NULL
 * @param data_points 数据点数组
 * @param max_count 最大数据点数量
 * @param actual_count 实际数据点数量
 * @return 获取结果，0表示成功
 */
int protocol_get_parsed_data(protocol_handle_t handle, 
                            data_point_t* data_points, 
                            int max_count, 
                            int* actual_count) {
    if (!handle || !data_points || !actual_count || max_count <= 0) {
        return -1;
    }
    
    // 这里应该从core内部获取解析后的数据
    // 暂时返回模拟数据
    *actual_count = 1;
    data_points[0].address = 0x1001;
    data_points[0].type = DATA_TYPE_SINGLE_POINT;
    data_points[0].quality = DATA_QUALITY_GOOD;
    data_points[0].timestamp = time(NULL) * 1000;
    data_points[0].value.single_point = true;
    
    LOG_INFO(LOG_MODULE_NAME, "获取解析数据: %d 个数据点", *actual_count);
    return 0;
}

/**
 * @brief 发送单点数据
 * @details 发送单点遥信数据
 * 
 * @param handle 协议句柄，不能为NULL
 * @param address 数据地址
 * @param value 数据值
 * @param quality 数据质量
 * @return 发送结果
 */
send_result_t protocol_send_single_point(protocol_handle_t handle, 
                                        uint32_t address, 
                                        bool value, 
                                        data_quality_t quality) {
    if (!handle) {
        return SEND_RESULT_FAILED;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "发送单点数据: 地址=0x%08X, 值=%s, 质量=%d", 
             address, value ? "ON" : "OFF", quality);
    
    // 这里应该调用core内部的发送函数
    // 暂时返回成功
    return SEND_RESULT_SUCCESS;
}

/**
 * @brief 发送双点数据
 * @details 发送双点遥信数据
 * 
 * @param handle 协议句柄，不能为NULL
 * @param address 数据地址
 * @param value 数据值
 * @param quality 数据质量
 * @return 发送结果
 */
send_result_t protocol_send_double_point(protocol_handle_t handle, 
                                        uint32_t address, 
                                        uint8_t value, 
                                        data_quality_t quality) {
    if (!handle) {
        return SEND_RESULT_FAILED;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "发送双点数据: 地址=0x%08X, 值=%d, 质量=%d", 
             address, value, quality);
    
    // 这里应该调用core内部的发送函数
    // 暂时返回成功
    return SEND_RESULT_SUCCESS;
}

/**
 * @brief 发送测量值数据
 * @details 发送遥测数据
 * 
 * @param handle 协议句柄，不能为NULL
 * @param address 数据地址
 * @param value 数据值
 * @param quality 数据质量
 * @return 发送结果
 */
send_result_t protocol_send_measurement(protocol_handle_t handle, 
                                       uint32_t address, 
                                       float value, 
                                       data_quality_t quality) {
    if (!handle) {
        return SEND_RESULT_FAILED;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "发送测量值: 地址=0x%08X, 值=%.2f, 质量=%d", 
             address, value, quality);
    
    // 这里应该调用core内部的发送函数
    // 暂时返回成功
    return SEND_RESULT_SUCCESS;
}

/**
 * @brief 发送控制命令
 * @details 发送遥控命令
 * 
 * @param handle 协议句柄，不能为NULL
 * @param address 控制地址
 * @param command 控制命令
 * @return 发送结果
 */
send_result_t protocol_send_control_command(protocol_handle_t handle, 
                                           uint32_t address, 
                                           uint8_t command) {
    if (!handle) {
        return SEND_RESULT_FAILED;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "发送控制命令: 地址=0x%08X, 命令=%d", 
             address, command);
    
    // 这里应该调用core内部的发送函数
    // 暂时返回成功
    return SEND_RESULT_SUCCESS;
}

const char* protocol_get_version(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取协议版本信息");
    
    const char* version = "1.0.0";
    LOG_INFO(LOG_MODULE_NAME, "协议版本: %s", version);
    
    return version;
}

/* ==================== 内部函数实现 ==================== */

/**
 * @brief 清理私有数据
 * @details 清理协议实例的私有数据结构，释放所有相关资源。
 *          该函数会销毁互斥锁并释放内存，调用后私有数据指针将不再有效。
 *          这是内部函数，通常由protocol_destroy()调用。
 * 
 * @param private_data 私有数据结构指针，可以为NULL
 * 
 * @note 该函数是内部函数，不应直接调用
 * @warning 调用此函数后，私有数据指针将不再有效
 * 
 * @see protocol_destroy
 * @see struct protocol_handle
 */
static void protocol_private_cleanup(struct protocol_handle* private_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "清理私有数据: private_data=%p", private_data);
    
    // 检查输入参数是否为空
    if (private_data == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "私有数据为空，跳过清理");
        return;
    }
    
    // 销毁互斥锁
    LOG_DEBUG(LOG_MODULE_NAME, "销毁互斥锁");
    pthread_mutex_destroy(&private_data->mutex);
    
    // 释放内存
    LOG_DEBUG(LOG_MODULE_NAME, "释放私有数据内存");
    free(private_data);
    
    LOG_INFO(LOG_MODULE_NAME, "私有数据清理完成");
}

/**
 * @brief 验证配置
 * @details 验证协议配置参数的有效性。该函数会检查服务器IP地址、
 *          服务器端口和公共地址等关键配置项，确保配置参数符合104协议要求。
 *          这是内部函数，通常由protocol_create()调用。
 * 
 * @param config 协议配置参数，不能为NULL
 * @return 验证结果
 *         - 0: 配置验证成功
 *         - -1: 配置验证失败
 * 
 * @note 该函数是内部函数，不应直接调用
 * @note 验证失败时会记录具体的错误信息
 * 
 * @see protocol_create
 * @see protocol_config_t
 */
static int protocol_private_validate_config(const protocol_config_t* config) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证协议配置: config=%p", config);
    
    // 验证服务器IP地址
    if (config->server_ip == NULL || strlen(config->server_ip) == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "服务器IP地址无效");
        return -1;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "服务器IP地址验证通过: %s", config->server_ip);
    
    // 验证服务器端口
    if (config->server_port == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "服务器端口无效: %u", config->server_port);
        return -1;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "服务器端口验证通过: %u", config->server_port);
    
    // 公共地址使用协议标准规定的宏定义，无需验证
    LOG_DEBUG(LOG_MODULE_NAME, "公共地址使用协议标准规定值: %u", PROTOCOL_104_COMMON_ADDRESS);
    
    LOG_INFO(LOG_MODULE_NAME, "协议配置验证成功");
    return 0;
}